Average case analysis of DJ graphs

AbstractSreedhar et al. [V.C. Sreedhar, G.R. Gao, Y.-F. Lee, A new framework for elimination-based data flow analysis using DJ graphs, ACM Trans. Program. Lang. Syst. 20 (2) (1998) 388–435; V.C. Sreedhar, Efficient program analysis using DJ graphs, PhD thesis, School of Computer Science, McGill University, Montréal, Québec, Canada, 1995] have presented an elimination-based algorithm to solve data flow problems. A thorough analysis of the algorithm shows that the worst-case performance is at least quadratic in the number of nodes of the underlying graph. In contrast, Sreedhar reports a linear time behavior based on some practical applications.In this paper we prove that for goto-free programs, the average case behavior is indeed linear. As a byproduct our result also applies to the average size of the so-called dominance frontier.A thorough average case analysis based on a graph grammar is performed by studying properties of the j-edges in DJ graphs. It appears that this is the first time that a graph grammar is used in order to analyze an algorithm. The average linear time of the algorithm is obtained by classic techniques in the analysis of algorithms and data structures such as singularity analysis of generating functions and transfer lemmas

Timing Analysis of Concurrent Programs

Worst-case execution time analysis of multi-threaded software is still a challenge. This comes mainly from the fact that the number of thread interleavings grows exponentially in the number of threads and that synchronization has to be taken into account. In particular, a suitable graph based model has been missing. The idea that thread interleavings can be studied with a matrix calculus is a novel approach in this research area. Our sparse matrix representations of the program are manipulated using Kronecker algebra. The resulting graph represents the multi-threaded program and plays a similar role for concurrent systems as control flow graphs do for sequential programs. Thus a suitable graph model for timing analysis of multi-threaded software has been set up. Due to synchronization it turns out that often only very small parts of the resulting graph are actually needed, whereas the rest is unreachable. A lazy implementation of the matrix operations ensures that the unreachable parts are never calculated. This speeds up processing significantly and shows that our approach is very promising

Shared Memory Concurrent System Verification using Kronecker Algebra

The verification of multithreaded software is still a challenge. This comes mainly from the fact that the number of thread interleavings grows exponentially in the number of threads. The idea that thread interleavings can be studied with a matrix calculus is a novel approach in this research area. Our sparse matrix representations of the program are manipulated using a lazy implementation of Kronecker algebra. One goal is the generation of a data structure called Concurrent Program Graph (CPG) which describes all possible interleavings and incorporates synchronization while preserving completeness. We prove that CPGs in general can be represented by sparse adjacency matrices. Thus the number of entries in the matrices is linear in their number of lines. Hence efficient algorithms can be applied to CPGs. In addition, due to synchronization only very small parts of the resulting matrix are actually needed, whereas the rest is unreachable in terms of automata. Thanks to the lazy implementation of the matrix operations the unreachable parts are never calculated. This speeds up processing significantly and shows that this approach is very promising. Various applications including data flow analysis can be performed on CPGs. Furthermore, the structure of the matrices can be used to prove properties of the underlying program for an arbitrary number of threads. For example, deadlock freedom is proved for a large class of programs.Comment: 31 page

Application of Kronecker algebra in railway operation

Predstavljamo metodologiju za otpremu vlakova koja sprečava potpune zastoje i uključuje moguća ograničenja raspoložive energije energetskog sustava. Naš pristup primjenjuje Kronekerovu algebru za manipuliranje matrica. Do blokiranja vlakova općenito dolazi zbog nedostatka nekog resursa, a to može biti ili infrastruktura ili energija. Naša se metoda može primijeniti i za grubi proračun putnih vremena. Vrijeme blokiranja je uključeno u proračunato putno vrijeme. Za prikaz kretanja vlakova u željezničkom sustavu rabimo grafikone, koji su prikazani matricama graničenja. Pretpostavljamo da su granice u grafikonu označene elementima polukruga. Za modeliranje sinhronizacije obično se grafikoni dvaju ili više različitih smjerova vlakova odnose na isti dio kolosijeka. Naš se pristup može primijeniti kod modeliranja složenog željezničkog sustava. Na primjer, ako treba programirati dodatne vlakove, zastoj u energetskoj centrali ili na spojnim pravcima, bilo zbog kvara ili održavanja, našim se modelom može izračunati kako se to odražava na putnom vremenu vlakova u sustavu.We present a methodology for dispatching trains which prevents deadlocks and includes possible limitation of the available energy provided by the power supply. Our approach applies Kronecker algebra to manipulate matrices. Generally blocking of trains occurs due to a lack of some resource which can be either infrastructure or energy. Our method can also be used to calculate travel times in a rough way. Thereby blocking time is included in the calculated travel time. To model the movements of trains in a railway system we use graphs, which are represented by adjacency matrices. We assume that the edges in a graph are labelled by elements of a semiring. Usually two or more distinct train route graphs refer to the same track section to model synchronization. Our approach can be used to model a complex railway system. For example, if additional trains have to be scheduled, power stations or interconnection lines fail or are not available due to maintenance, our model can be used to calculate the impact on the travel times of the trains in the system

Average Case Analysis of Some Elimination-Based Data-Flow Analysis Algorithms

The average case of some elimination-based data-flow analysis algorithms is analyzed in a mathematical way. Besides this allows for comparing the timing behavior of the algorithms, it also provides insights into how relevant the underlying statistics are when compared to practical settings

Monotonically labelled Motzkin trees

Consider a rooted tree structure the nodes of which have been labelled monotonically by elements of { 1, 2,...,k}, which means that any sequence connecting the root of the tree with a leaf is weakly monotone. For fixed k asymptotic equivalents of the form CA gA °n-; 2 (n--oo) to the numbers of such tree structures with n nodes are obtained for the family of extended unary-binary trees (i.e., Motzkin trees) and for the family of extended unary-t-ary trees. Furthermore the numbers of (not extended) monotonically labelled binary and unary-binary trees are studied. For each of these families the asymptotic behaviour of qA- as k-- is determined. This is done by investigating a non-linear function sequence. The roots of the functions of this function se-quence equal qA.. Thus one finds for instance qA.- (log 2)/k (k-goo) for the family of extended unary-binary trees, and qA.-R/2k (k--oo) for the family of binary trees.

AVERAGE CASE ANALYSIS OF DJ GRAPHS

Abstract. Sreedhar et al. [SGL98, Sre95] have presented an eliminationbased algorithm to solve data flow problems. A thorough analysis of the algorithm shows that the worst-case performance is at least quadratic in the number of nodes of the underlying graph. In contrast, Sreedhar reports a linear time behavior based on some practical applications. In this paper we prove that for goto-free programs, the average case behavior is indeed linear. As a byproduct our result also applies to the average size of the so-called dominance frontier. A thorough average case analysis based on a graph grammar is performed by studying properties of the j-edges in DJ graphs. It appears that this is the first time that a graph grammar is used in order to analyze an algorithm. The average linear time of the algorithm is obtained by classic techniques in the analysis of algorithms and data structures such as singularity analysis of generating functions and transfer lemmas. 1